/**
 * 创建DSYWidget管理器
 */
if (!window.DSYWidget) {
    window.DSYWidget = {
        Manager: {
            searchTool: {}
        }
    };
} else if (!window.DSYWidget.Manager) {
	window.DSYWidget.Manager = {
        searchTool: {}
    };
} else if (!window.DSYWidget.Manager.searchTool) {
	window.DSYWidget.Manager.searchTool = {};
}
/**
 * 创建查询控件封装对象
 *
 * @returns {DSYSearchTool}
 */
function DSYSearchTool() {
    this.searchToolId = null;//查询控件id
    //搜索工具栏
    var searchToolBar = {
        //renderTo: null,//用户默认指向，若无renderTo，
        layout: {
            type: 'column'
        },
        defaults: {
            margin: '5 5 5 5',
            //height: 40,
            //width: 250,
            columnWidth:0.32,
            labelWidth: 100,//控件默认标签宽度
            labelAlign: 'right'//控件默认标签对齐方式
        },
        /**
         * 控件数组
         * @example:
         {
             fieldLabel: '搜索框',
            labelAlign:'right',
            labelWidth: 50,
            xtype: 'textfield',//控件类型：支持radiogroup、textfield、combobox/combo、datefield、multicombobox
            paramName:'search'
         }
         */
        items: [],
        /*dockedItems: [{
         xtype: 'toolbar',
         dock: 'right',
         ui: 'footer',
         items: [
         {
         xtype: 'button',
         text: '查询',
         margin: '5 5 10 5',
         width: 50,
         formBind: true,
         disabled: true,
         handler: function () {
         }
         }
         ]
         }],*/
        //查询按钮回调函数
        callback: function (search_form) {
        }
    };

    this.getSearchToolId = function () {
        return searchToolId;
    };
    this.setSearchToolId = function (searchToolId) {
        this.searchToolId = searchToolId + "-DSYSearchTool";
        searchToolBar.itemId = this.searchToolId;
    };
    this.getSearchToolBar = function () {
        return searchToolBar;
    };
    this.setSearchToolBar = function (_searchToolBar) {
        if (typeof(_searchToolBar) == "object") {
            jQuery.extend(true, searchToolBar, _searchToolBar);
        }
    };
    /**
     * 创建搜索区域
     */
    this.create = function (_searchToolBar) {
        //设置相关配置
        this.setSearchToolBar(_searchToolBar);
        // 开启动态加载
        Ext.Loader.setConfig({enabled: true});
        Ext.require([
            'Ext.data.*',
            'Ext.util.*',
            'Ext.tip.QuickTipManager'
        ]);
        Ext.QuickTips.init();
        Ext.tip.QuickTipManager.init();
        if (searchToolBar.items.length <= 0) {
            return;
        }
        //循环初始化查询组件
        for (var item_seq in searchToolBar.items) {
            var item = searchToolBar.items[item_seq];
            if (item.xtype == 'textfield') {
            } else if (item.xtype == 'datefield') {
                // 如果是日期型，格式化日期
                item.format = item.format ? item.format : 'Y-m-d';
            } else if (item.xtype == 'combobox' || item.xtype == 'combo' || item.xtype == 'multicombobox') {
                // 如果是下拉框，生成store
                item.editable = item.editable ? item.editable : false;
                // 判断数据源是json还是代理
                if (item.data) {
                    item.store = Ext.create('Ext.data.Store', {
                        fields: [item.displayField, item.valueField],
                        data: item.data
                    });
                    delete item.data;
                } else if (item.url) {
                    item.store = Ext.create('Ext.data.Store', {
                        fields: [item.displayField, item.valueField],
                        proxy: {
                            type: "ajax",
                            url: item.url
                        }
                    });
                }
            } else if (item.xtype == 'radiogroup') {
                //如果是单选框组，取消单选框组名称，给每个选项加上名称
                item.defaults = {
                    name: item.name
                };
                item.name = null;
            } else if (item.xtype == 'checkboxgroup') {
                //如果是复选框组，取消复选框组名称，给每个选项加上名称
                item.defaults = {
                    name: item.name
                };
                item.name = null;
            } else if (item.xtype == 'singletree' || item.xtype == 'multitree') {
                //如果是树形控件，则生成下拉框，点击下拉框弹出window窗口，window中为tree
                if (item.xtype == 'singletree') {
                    item.multi = false;
                } else if (item.xtype == 'multitree') {
                    item.multi = true;
                }
                item.xtype = 'combobox';
                item.editable = item.editable ? item.editable : false;
                // 创建store,判断tree数据源是json还是代理
                if (item.data) {
                    item.treeStore = Ext.create('Ext.data.TreeStore', {
                        root: item.data
                    });
                    delete item.data;
                } else if (item.url) {
                    item.treeStore = Ext.create('Ext.data.TreeStore', {
                        root: 'root',
                        proxy: {
                            type: 'ajax',
                            method: 'POST',
                            url: item.url,
                            reader: {
                                type: 'json'
                            }
                        }
                    });
                }

                if (!item.listeners) {
                    item.listeners = {};
                }
                // 下拉框点击展开事件：显示弹出框，如果没有弹出框/弹出框已销毁，创建tree，再创建弹出框
                item.listeners.expand = treeComboboxExpand();
            }
        }
        //初始化查询form
        this.search_form = Ext.create('Ext.form.Panel', searchToolBar);
        //在form中添加查询按钮
        this.search_form.add({
            xtype: 'toolbar',
            border: false,
            width: 140,
            padding: '0 0 0 0',
            margin: '5 5 5 ' + (10 + Number(searchToolBar.defaults.labelWidth)),
            items: [
                {
                    xtype: 'button',
                    text: '查询',
                    icon: '/report/image/sysbutton/search.png',
                    handler: function () {
                        var form = this.up('form');
                        if (form.isValid()) {
                            searchToolBar.callback(form);
                        } else {
                            Ext.Msg.alert("提示", "查询区域未通过验证！");
                        }
                    }
                },
                {
                    xtype: 'button',
                    text: '重置',
                    icon: '/report/image/sysbutton/cancel.png',
                    handler: function () {
                        var form = this.up('form');
                        form.reset();
                    }
                }
            ]
        });
        //将本DSYSearchTool放入管理器
        DSYWidget.Manager.searchTool[this.searchToolId] = this;
        return this.search_form;
    };
}
/**
 * 创建弹出树下拉框的下拉监听事件，该事件创建树和弹出窗口
 */
function treeComboboxExpand() {
    var expand = function (button) {
        if (!button.treeWindow || button.treeWindow.closeAction == 'destroy') {
            // 获取显示字段，若无，默认text
            var displayField = button.displayField ? button.displayField : 'text';
            // 创建树
            button.tree = Ext.create('Ext.tree.Panel', {
                store: button.treeStore,
                autoScroll: true,
                folderSort: true,
                singleExpand: false,//展示单个子节点，其它的子节点合并
                useArrows: false,//树节点是否使用箭头
                rootVisible: false,//隐藏根节点
                animate: true,//动画效果
                hideHeaders: true,//隐藏列表头
                columns: [
                    {
                        xtype: 'treecolumn',
                        dataIndex: Ext.isArray(displayField) ? displayField[0] : displayField,
                        flex: 1,
                        renderer: function (data, cell, record) {
                            // 若显示字段为数组，进行多字段组合
                            var data_record = '';
                            if (Ext.isArray(displayField)) {
                                for (var i in displayField) {
                                    data_record += record.get(displayField[i]) + " ";
                                }
                            } else {
                                data_record = data;
                            }
                            return data_record;
                        }
                    }
                ]
            });
            // 当树是多选时，添加父子节点级联
            if (button.multi == true) {
                button.tree.on('checkchange', function (node, state) {
                    // 选中或取消全部子节点
                    if (!node.isLeaf()) {
                        node.cascadeBy(function (childNode) {
                            childNode.set('checked', state);
                        });
                    }
                    if (!node.isRoot()) {
                        // 遍历父节点，若子节点均选中则选中，否则取消选中
                        node.bubble(function (pNode) {
                            if (pNode.isRoot()) {
                                return;
                            }
                            var flag = state;
                            if (flag && !pNode.isLeaf()) {
                                // 当选中当前节点，遍历节点的一级子节点
                                pNode.eachChild(function (childNode) {
                                    if (!childNode.get('checked')) {
                                        flag = false;
                                        return false;
                                    }
                                });
                            }
                            pNode.set("checked", flag);
                        });
                    }
                });
            }
            // 创建弹出窗口
            button.treeWindow = Ext.create('Ext.window.Window', {
                closeAction: "hide",//hide：关闭时隐藏弹出框；destroy：关闭时销毁
                title: button.fieldLabel ? button.fieldLabel : null,
                width: 600,
                height: 337.5,
                layout: 'fit',
                modal: true,
                animateTarget: button,
                buttonAlign: 'center',
                buttons: [
                    {
                        text: '确认', listeners: {
                        'click': function (btn) {
                            //点击确认按钮修改combobox值为tree值
                            var tree = btn.up("window").down('treepanel');
                            //获取树的值数组，若是不需要复选框，改getChecked为getSelection即可
                            var treeValueArray = (button.multi == true) ? tree.getChecked() : tree.getSelection();
                            var comboboxValue = new Array(treeValueArray.length);
                            var comboboxText = '';
                            // 遍历数组生成下拉框值数组
                            for (var i = 0; i < treeValueArray.length; i++) {
                                comboboxValue[i] = treeValueArray[i].get(button.valueField);
                                if (Ext.isArray(displayField)) {
                                    for (var j in displayField) {
                                        comboboxText += treeValueArray[i].get(displayField[j]) + " ";
                                    }
                                    comboboxText += ';';
                                } else {
                                    comboboxText += treeValueArray[i].get(button.displayField ? button.displayField : 'text') + ';';
                                }
                            }
                            // 给下拉框设置值与显示值
                            button.setValue(comboboxValue);
                            button.setRawValue(comboboxText);
                            // 关闭弹出窗口
                            btn.up("window").close();
                        }
                    }
                    },
                    {
                        text: '取消', listeners: {
                        'click': function (btn) {
                            btn.up("window").close();
                        }
                    }
                    }
                ],
                items: [button.tree]
            });
        }
        button.treeWindow.show();
        // 获取下拉框值，并回显到tree上
        var button_value = button.getValue();
        if (button_value != null && button_value.length > 0) {
            button.treeStore.getRoot().cascadeBy(function (node) {
                // 获取遍历节点的值
                var node_value = node.get(button.valueField);
                if (button.multi == true) {
                    // 如果是多选tree，设置checked
                    if (node_value && button_value.indexOf(node_value) >= 0) {
                        node.set('checked', true);
                    } else {
                        node.set('checked', false);
                    }
                } else {
                    // 如果是单选tree，直接select
                    if (node_value && button_value.indexOf(node_value) >= 0) {
                        button.tree.getSelectionModel().select(node);
                    }
                }
            });
        }
    };
    expand();
    //return expand;
}
/**
 * 搜索区域创建方法
 */
DSYSearchTool.createTool = function (config) {
    return new DSYSearchTool().create(config);
};
/**
 * 创建获取搜索区域方法
 */
DSYSearchTool.getSearchTool = function (searchToolId) {
    return DSYWidget.Manager.searchTool(searchToolId).searchTool;
};
/**
 * 从DSYSearchTool管理器中销毁DSYSearchTool
 * @param searchToolId
 */
DSYSearchTool.destorySearchTool = function (searchToolId) {
    if (DSYSearchTool.getSearchTool(searchToolId)) {
        return;
    }
    DSYSearchTool.getSearchTool(searchToolId).close();
    delete DSYWidget.Manager.searchTool[searchToolId];
};
/**
 * ext扩展插件：表单多选下拉框（带checkbox）
 */
Ext.define('Ext.ux.MultiComboBox', {
    extend: 'Ext.form.ComboBox',
    alias: 'widget.multicombobox',
    initComponent: function () {
        this.multiSelect = true;//设置combobox的多选项为true
        this.editable = false;
        this.listConfig = {
            itemTpl: Ext.create('Ext.XTemplate', '<input type="checkbox">{' + this.displayField + '}'),//为	选项添加checkbox
            //解决问题：选中之后， 下一次点击下拉单的话，会更新 combobox 的下拉选项(combobox), 之前选中的check box 会被取消选择。
            onItemSelect: function (record) {
                var node = this.getNode(record);
                if (node) {
                    Ext.fly(node).addCls(this.selectedItemCls);

                    var checkboxs = node.getElementsByTagName("input");
                    if (checkboxs != null) {
                        var checkbox = checkboxs[0];
                        checkbox.checked = true;
                    }
                }
            },
            listeners: {
                //监听事件：选项选中或取消时，操作对应checkbox
                itemclick: function (view, record, item) {
                    var isSelected = view.isSelected(item);
                    var checkboxs = item.getElementsByTagName("input");
                    if (checkboxs != null) {
                        var checkbox = checkboxs[0];
                        checkbox.checked = !isSelected;
                    }
                }
            }
        };
        this.callParent();
    }
});
